/**
*  Copyright (c) 2011, Alex Theodoridis
*  All rights reserved.

*  Redistribution and use in source and binary forms, with
*  or without modification, are permitted provided that the
*  following conditions are met:
*  Redistributions of source code must retain the above
*  copyright notice, this list of conditions and the following disclaimer.
*  Redistributions in binary form must reproduce the above
*  copyright notice, this list of conditions and the following
*  disclaimer in the documentation and/or other materials
*  provided with the distribution.

*  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS
*  AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
*  INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
*  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
*  IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
*  ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
*  OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
*  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
*  OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
*  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
*  OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
*  ANY WAY OUT OF THE USE OF THIS SOFTWARE,
*  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE
*/

#ifndef UTILS_STRATEGY_H
#define UTILS_STRATEGY_H

namespace utils {

/**
 * @author alekstheod
 * Template implementation of the Strategy design pattern.
 */
template<class T>
class Strategy {
private:
    /**
     * Pointer to the instance which represent the
     * strategy.
     */
    T* _strategy;

public:
    /**
     * Empty constructor.
     */
    Strategy() {
    }

    /**
     * Will compaire the strategy
     * instance with the given one.
     * @param ptr the instance of
     * the strategy to be compaired.
     * @return true if the given instance
     * is the same with the internal strategy,
     * false otherwise.
     */
    bool operator==(T* ptr) {
        return ptr == _strategy;
    }

    /**
     * Will compaire the strategy
     * instance with the given one.
     * @param ptr the instance of
     * the strategy to be compaired.
     * @return true if the given instance
     * is different than the internal strategy,
     * false otherwise.
     */
    bool operator!=(T* ptr) {
        return ptr != _strategy;
    }

    /**
     * Will return the instance of the
     * internal strategy.
     * @return the instance of the internal strategy.
     */
    T* operator->() {
        return _strategy;
    }

    /**
    * Will register a new strategy.
    * @param strategy instance of the new strategy
    * to be registered.
    */
    void registerStrategy(T* strategy) {
        _strategy = strategy;
    }

    /**
     * Destructor.
     */
    virtual ~Strategy() {
    }
};
}

#endif
